// $ANTLR 3.3 Nov 30, 2010 12:45:30 C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g 2011-06-26 23:22:27

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
public class HbaseSQLLexer extends Lexer {
    public static final int EOF=-1;
    public static final int Eq=4;
    public static final int Neq1=5;
    public static final int Neq2=6;
    public static final int Le1=7;
    public static final int Le2=8;
    public static final int Lt=9;
    public static final int Ge1=10;
    public static final int Ge2=11;
    public static final int Gt=12;
    public static final int DIV=13;
    public static final int PLUS=14;
    public static final int MINUS=15;
    public static final int MUL=16;
    public static final int MOD=17;
    public static final int BITAND=18;
    public static final int BITNOT=19;
    public static final int BITOR=20;
    public static final int BITXOR=21;
    public static final int LPAREN=22;
    public static final int RPAREN=23;
    public static final int COLON=24;
    public static final int COMMA=25;
    public static final int SEMI=26;
    public static final int DOT=27;
    public static final int ALL=28;
    public static final int AND=29;
    public static final int AS=30;
    public static final int ASC=31;
    public static final int BETWEEN=32;
    public static final int BY=33;
    public static final int CASE=34;
    public static final int CROSS=35;
    public static final int DELETE=36;
    public static final int DESC=37;
    public static final int DISTINCT=38;
    public static final int ELSE=39;
    public static final int END=40;
    public static final int EXISTS=41;
    public static final int FOR=42;
    public static final int FROM=43;
    public static final int GROUP=44;
    public static final int HAVING=45;
    public static final int IN=46;
    public static final int INNER=47;
    public static final int INSERT=48;
    public static final int INTO=49;
    public static final int IS=50;
    public static final int JOIN=51;
    public static final int LEFT=52;
    public static final int LIKE=53;
    public static final int NOT=54;
    public static final int NULL=55;
    public static final int ON=56;
    public static final int OR=57;
    public static final int ORDER=58;
    public static final int OUTER=59;
    public static final int RIGHT=60;
    public static final int SELECT=61;
    public static final int SET=62;
    public static final int THEN=63;
    public static final int UNION=64;
    public static final int UPDATE=65;
    public static final int VALUES=66;
    public static final int WHEN=67;
    public static final int WHERE=68;
    public static final int TRUNCATE=69;
    public static final int SUM=70;
    public static final int AVG=71;
    public static final int MAX=72;
    public static final int MIN=73;
    public static final int COUNT=74;
    public static final int LEN=75;
    public static final int CHAR=76;
    public static final int NCHAR=77;
    public static final int VARCHAR=78;
    public static final int NVARCHAR=79;
    public static final int TEXT=80;
    public static final int NTEXT=81;
    public static final int DATETIME=82;
    public static final int INT=83;
    public static final int DECIMAL=84;
    public static final int BINARY=85;
    public static final int CREATE=86;
    public static final int TABLE=87;
    public static final int DROP=88;
    public static final int QuotedIdentifier=89;
    public static final int NonQuotedIdentifier=90;
    public static final int Integer=91;
    public static final int StringLiteral=92;
    public static final int Real=93;
    public static final int UserVariable=94;
    public static final int Whitespace=95;
    public static final int SingleLineComment=96;
    public static final int MultiLineComment=97;
    public static final int DigitChar=98;
    public static final int NonQuotedIdentifier_0=99;
    public static final int LetterChar=100;
    public static final int TextNode=101;
    public static final int SelectClause=102;
    public static final int UnionStmt=103;
    public static final int SelectStmt=104;
    public static final int WhereClause=105;
    public static final int GroupByClause=106;
    public static final int OrderByClause=107;
    public static final int OrderByItem=108;
    public static final int UpdateClause=109;
    public static final int UpdateStmt=110;
    public static final int DeleteClause=111;
    public static final int DeleteStmt=112;
    public static final int InsertClause=113;
    public static final int InsertStmt=114;
    public static final int Alias=115;
    public static final int Table=116;
    public static final int JoinedTable=117;
    public static final int Column=118;
    public static final int Predicate=119;
    public static final int Predicate_Is=120;
    public static final int DataType=121;
    public static final int Group=122;
    public static final int UserFunction=123;

    // delegates
    // delegators

    public HbaseSQLLexer() {;} 
    public HbaseSQLLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public HbaseSQLLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g"; }

    // $ANTLR start "Eq"
    public final void mEq() throws RecognitionException {
        try {
            int _type = Eq;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:7:4: ( '=' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:7:6: '='
            {
            match('='); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Eq"

    // $ANTLR start "Neq1"
    public final void mNeq1() throws RecognitionException {
        try {
            int _type = Neq1;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:8:6: ( '<>' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:8:8: '<>'
            {
            match("<>"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Neq1"

    // $ANTLR start "Neq2"
    public final void mNeq2() throws RecognitionException {
        try {
            int _type = Neq2;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:9:6: ( '!=' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:9:8: '!='
            {
            match("!="); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Neq2"

    // $ANTLR start "Le1"
    public final void mLe1() throws RecognitionException {
        try {
            int _type = Le1;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:10:5: ( '<=' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:10:7: '<='
            {
            match("<="); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Le1"

    // $ANTLR start "Le2"
    public final void mLe2() throws RecognitionException {
        try {
            int _type = Le2;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:11:5: ( '!>' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:11:7: '!>'
            {
            match("!>"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Le2"

    // $ANTLR start "Lt"
    public final void mLt() throws RecognitionException {
        try {
            int _type = Lt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:12:4: ( '<' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:12:6: '<'
            {
            match('<'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Lt"

    // $ANTLR start "Ge1"
    public final void mGe1() throws RecognitionException {
        try {
            int _type = Ge1;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:13:5: ( '>=' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:13:7: '>='
            {
            match(">="); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Ge1"

    // $ANTLR start "Ge2"
    public final void mGe2() throws RecognitionException {
        try {
            int _type = Ge2;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:14:5: ( '!<' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:14:7: '!<'
            {
            match("!<"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Ge2"

    // $ANTLR start "Gt"
    public final void mGt() throws RecognitionException {
        try {
            int _type = Gt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:15:4: ( '>' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:15:6: '>'
            {
            match('>'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Gt"

    // $ANTLR start "DIV"
    public final void mDIV() throws RecognitionException {
        try {
            int _type = DIV;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:16:5: ( '/' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:16:7: '/'
            {
            match('/'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DIV"

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:17:6: ( '+' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:17:8: '+'
            {
            match('+'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MINUS"
    public final void mMINUS() throws RecognitionException {
        try {
            int _type = MINUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:18:7: ( '-' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:18:9: '-'
            {
            match('-'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "MUL"
    public final void mMUL() throws RecognitionException {
        try {
            int _type = MUL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:19:5: ( '*' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:19:7: '*'
            {
            match('*'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MUL"

    // $ANTLR start "MOD"
    public final void mMOD() throws RecognitionException {
        try {
            int _type = MOD;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:20:5: ( '%' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:20:7: '%'
            {
            match('%'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MOD"

    // $ANTLR start "BITAND"
    public final void mBITAND() throws RecognitionException {
        try {
            int _type = BITAND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:21:8: ( '&' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:21:10: '&'
            {
            match('&'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BITAND"

    // $ANTLR start "BITNOT"
    public final void mBITNOT() throws RecognitionException {
        try {
            int _type = BITNOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:22:8: ( '~' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:22:10: '~'
            {
            match('~'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BITNOT"

    // $ANTLR start "BITOR"
    public final void mBITOR() throws RecognitionException {
        try {
            int _type = BITOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:23:7: ( '|' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:23:9: '|'
            {
            match('|'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BITOR"

    // $ANTLR start "BITXOR"
    public final void mBITXOR() throws RecognitionException {
        try {
            int _type = BITXOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:24:8: ( '^' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:24:10: '^'
            {
            match('^'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BITXOR"

    // $ANTLR start "LPAREN"
    public final void mLPAREN() throws RecognitionException {
        try {
            int _type = LPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:25:8: ( '(' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:25:10: '('
            {
            match('('); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LPAREN"

    // $ANTLR start "RPAREN"
    public final void mRPAREN() throws RecognitionException {
        try {
            int _type = RPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:26:8: ( ')' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:26:10: ')'
            {
            match(')'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RPAREN"

    // $ANTLR start "COLON"
    public final void mCOLON() throws RecognitionException {
        try {
            int _type = COLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:27:7: ( ':' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:27:9: ':'
            {
            match(':'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COLON"

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:28:7: ( ',' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:28:9: ','
            {
            match(','); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "SEMI"
    public final void mSEMI() throws RecognitionException {
        try {
            int _type = SEMI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:29:6: ( ';' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:29:8: ';'
            {
            match(';'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SEMI"

    // $ANTLR start "DOT"
    public final void mDOT() throws RecognitionException {
        try {
            int _type = DOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:30:5: ( '.' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:30:7: '.'
            {
            match('.'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "ALL"
    public final void mALL() throws RecognitionException {
        try {
            int _type = ALL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:31:5: ( 'all' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:31:7: 'all'
            {
            match("all"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ALL"

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:32:5: ( 'and' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:32:7: 'and'
            {
            match("and"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "AS"
    public final void mAS() throws RecognitionException {
        try {
            int _type = AS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:33:4: ( 'as' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:33:6: 'as'
            {
            match("as"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AS"

    // $ANTLR start "ASC"
    public final void mASC() throws RecognitionException {
        try {
            int _type = ASC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:34:5: ( 'asc' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:34:7: 'asc'
            {
            match("asc"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ASC"

    // $ANTLR start "BETWEEN"
    public final void mBETWEEN() throws RecognitionException {
        try {
            int _type = BETWEEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:35:9: ( 'between' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:35:11: 'between'
            {
            match("between"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BETWEEN"

    // $ANTLR start "BY"
    public final void mBY() throws RecognitionException {
        try {
            int _type = BY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:36:4: ( 'by' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:36:6: 'by'
            {
            match("by"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BY"

    // $ANTLR start "CASE"
    public final void mCASE() throws RecognitionException {
        try {
            int _type = CASE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:37:6: ( 'case' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:37:8: 'case'
            {
            match("case"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CASE"

    // $ANTLR start "CROSS"
    public final void mCROSS() throws RecognitionException {
        try {
            int _type = CROSS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:38:7: ( 'cross' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:38:9: 'cross'
            {
            match("cross"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CROSS"

    // $ANTLR start "DELETE"
    public final void mDELETE() throws RecognitionException {
        try {
            int _type = DELETE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:39:8: ( 'delete' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:39:10: 'delete'
            {
            match("delete"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DELETE"

    // $ANTLR start "DESC"
    public final void mDESC() throws RecognitionException {
        try {
            int _type = DESC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:40:6: ( 'desc' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:40:8: 'desc'
            {
            match("desc"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DESC"

    // $ANTLR start "DISTINCT"
    public final void mDISTINCT() throws RecognitionException {
        try {
            int _type = DISTINCT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:41:10: ( 'distinct' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:41:12: 'distinct'
            {
            match("distinct"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DISTINCT"

    // $ANTLR start "ELSE"
    public final void mELSE() throws RecognitionException {
        try {
            int _type = ELSE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:42:6: ( 'else' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:42:8: 'else'
            {
            match("else"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ELSE"

    // $ANTLR start "END"
    public final void mEND() throws RecognitionException {
        try {
            int _type = END;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:43:5: ( 'end' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:43:7: 'end'
            {
            match("end"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "END"

    // $ANTLR start "EXISTS"
    public final void mEXISTS() throws RecognitionException {
        try {
            int _type = EXISTS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:44:8: ( 'exists' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:44:10: 'exists'
            {
            match("exists"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EXISTS"

    // $ANTLR start "FOR"
    public final void mFOR() throws RecognitionException {
        try {
            int _type = FOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:45:5: ( 'for' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:45:7: 'for'
            {
            match("for"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FOR"

    // $ANTLR start "FROM"
    public final void mFROM() throws RecognitionException {
        try {
            int _type = FROM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:46:6: ( 'from' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:46:8: 'from'
            {
            match("from"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FROM"

    // $ANTLR start "GROUP"
    public final void mGROUP() throws RecognitionException {
        try {
            int _type = GROUP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:47:7: ( 'group' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:47:9: 'group'
            {
            match("group"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GROUP"

    // $ANTLR start "HAVING"
    public final void mHAVING() throws RecognitionException {
        try {
            int _type = HAVING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:48:8: ( 'having' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:48:10: 'having'
            {
            match("having"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "HAVING"

    // $ANTLR start "IN"
    public final void mIN() throws RecognitionException {
        try {
            int _type = IN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:49:4: ( 'in' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:49:6: 'in'
            {
            match("in"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IN"

    // $ANTLR start "INNER"
    public final void mINNER() throws RecognitionException {
        try {
            int _type = INNER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:50:7: ( 'inner' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:50:9: 'inner'
            {
            match("inner"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INNER"

    // $ANTLR start "INSERT"
    public final void mINSERT() throws RecognitionException {
        try {
            int _type = INSERT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:51:8: ( 'insert' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:51:10: 'insert'
            {
            match("insert"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INSERT"

    // $ANTLR start "INTO"
    public final void mINTO() throws RecognitionException {
        try {
            int _type = INTO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:52:6: ( 'into' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:52:8: 'into'
            {
            match("into"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INTO"

    // $ANTLR start "IS"
    public final void mIS() throws RecognitionException {
        try {
            int _type = IS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:53:4: ( 'is' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:53:6: 'is'
            {
            match("is"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IS"

    // $ANTLR start "JOIN"
    public final void mJOIN() throws RecognitionException {
        try {
            int _type = JOIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:54:6: ( 'join' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:54:8: 'join'
            {
            match("join"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "JOIN"

    // $ANTLR start "LEFT"
    public final void mLEFT() throws RecognitionException {
        try {
            int _type = LEFT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:55:6: ( 'left' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:55:8: 'left'
            {
            match("left"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEFT"

    // $ANTLR start "LIKE"
    public final void mLIKE() throws RecognitionException {
        try {
            int _type = LIKE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:56:6: ( 'like' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:56:8: 'like'
            {
            match("like"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LIKE"

    // $ANTLR start "NOT"
    public final void mNOT() throws RecognitionException {
        try {
            int _type = NOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:57:5: ( 'not' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:57:7: 'not'
            {
            match("not"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "NULL"
    public final void mNULL() throws RecognitionException {
        try {
            int _type = NULL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:58:6: ( 'null' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:58:8: 'null'
            {
            match("null"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NULL"

    // $ANTLR start "ON"
    public final void mON() throws RecognitionException {
        try {
            int _type = ON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:59:4: ( 'on' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:59:6: 'on'
            {
            match("on"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ON"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:60:4: ( 'or' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:60:6: 'or'
            {
            match("or"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "ORDER"
    public final void mORDER() throws RecognitionException {
        try {
            int _type = ORDER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:61:7: ( 'order' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:61:9: 'order'
            {
            match("order"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ORDER"

    // $ANTLR start "OUTER"
    public final void mOUTER() throws RecognitionException {
        try {
            int _type = OUTER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:62:7: ( 'outer' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:62:9: 'outer'
            {
            match("outer"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OUTER"

    // $ANTLR start "RIGHT"
    public final void mRIGHT() throws RecognitionException {
        try {
            int _type = RIGHT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:63:7: ( 'right' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:63:9: 'right'
            {
            match("right"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RIGHT"

    // $ANTLR start "SELECT"
    public final void mSELECT() throws RecognitionException {
        try {
            int _type = SELECT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:64:8: ( 'select' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:64:10: 'select'
            {
            match("select"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SELECT"

    // $ANTLR start "SET"
    public final void mSET() throws RecognitionException {
        try {
            int _type = SET;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:65:5: ( 'set' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:65:7: 'set'
            {
            match("set"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SET"

    // $ANTLR start "THEN"
    public final void mTHEN() throws RecognitionException {
        try {
            int _type = THEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:66:6: ( 'then' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:66:8: 'then'
            {
            match("then"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "THEN"

    // $ANTLR start "UNION"
    public final void mUNION() throws RecognitionException {
        try {
            int _type = UNION;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:67:7: ( 'union' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:67:9: 'union'
            {
            match("union"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UNION"

    // $ANTLR start "UPDATE"
    public final void mUPDATE() throws RecognitionException {
        try {
            int _type = UPDATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:68:8: ( 'update' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:68:10: 'update'
            {
            match("update"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UPDATE"

    // $ANTLR start "VALUES"
    public final void mVALUES() throws RecognitionException {
        try {
            int _type = VALUES;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:69:8: ( 'values' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:69:10: 'values'
            {
            match("values"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VALUES"

    // $ANTLR start "WHEN"
    public final void mWHEN() throws RecognitionException {
        try {
            int _type = WHEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:70:6: ( 'when' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:70:8: 'when'
            {
            match("when"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHEN"

    // $ANTLR start "WHERE"
    public final void mWHERE() throws RecognitionException {
        try {
            int _type = WHERE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:71:7: ( 'where' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:71:9: 'where'
            {
            match("where"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHERE"

    // $ANTLR start "TRUNCATE"
    public final void mTRUNCATE() throws RecognitionException {
        try {
            int _type = TRUNCATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:72:10: ( 'truncate' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:72:12: 'truncate'
            {
            match("truncate"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TRUNCATE"

    // $ANTLR start "SUM"
    public final void mSUM() throws RecognitionException {
        try {
            int _type = SUM;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:73:5: ( 'sum' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:73:7: 'sum'
            {
            match("sum"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SUM"

    // $ANTLR start "AVG"
    public final void mAVG() throws RecognitionException {
        try {
            int _type = AVG;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:74:5: ( 'avg' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:74:7: 'avg'
            {
            match("avg"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AVG"

    // $ANTLR start "MAX"
    public final void mMAX() throws RecognitionException {
        try {
            int _type = MAX;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:75:5: ( 'max' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:75:7: 'max'
            {
            match("max"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MAX"

    // $ANTLR start "MIN"
    public final void mMIN() throws RecognitionException {
        try {
            int _type = MIN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:76:5: ( 'min' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:76:7: 'min'
            {
            match("min"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MIN"

    // $ANTLR start "COUNT"
    public final void mCOUNT() throws RecognitionException {
        try {
            int _type = COUNT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:77:7: ( 'count' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:77:9: 'count'
            {
            match("count"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COUNT"

    // $ANTLR start "LEN"
    public final void mLEN() throws RecognitionException {
        try {
            int _type = LEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:78:5: ( 'len' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:78:7: 'len'
            {
            match("len"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LEN"

    // $ANTLR start "CHAR"
    public final void mCHAR() throws RecognitionException {
        try {
            int _type = CHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:79:6: ( 'char' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:79:8: 'char'
            {
            match("char"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CHAR"

    // $ANTLR start "NCHAR"
    public final void mNCHAR() throws RecognitionException {
        try {
            int _type = NCHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:80:7: ( 'nchar' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:80:9: 'nchar'
            {
            match("nchar"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NCHAR"

    // $ANTLR start "VARCHAR"
    public final void mVARCHAR() throws RecognitionException {
        try {
            int _type = VARCHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:81:9: ( 'varchar2' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:81:11: 'varchar2'
            {
            match("varchar2"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VARCHAR"

    // $ANTLR start "NVARCHAR"
    public final void mNVARCHAR() throws RecognitionException {
        try {
            int _type = NVARCHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:82:10: ( 'nvarchar2' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:82:12: 'nvarchar2'
            {
            match("nvarchar2"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NVARCHAR"

    // $ANTLR start "TEXT"
    public final void mTEXT() throws RecognitionException {
        try {
            int _type = TEXT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:83:6: ( 'clob' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:83:8: 'clob'
            {
            match("clob"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TEXT"

    // $ANTLR start "NTEXT"
    public final void mNTEXT() throws RecognitionException {
        try {
            int _type = NTEXT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:84:7: ( 'nclob' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:84:9: 'nclob'
            {
            match("nclob"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NTEXT"

    // $ANTLR start "DATETIME"
    public final void mDATETIME() throws RecognitionException {
        try {
            int _type = DATETIME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:85:10: ( 'date' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:85:12: 'date'
            {
            match("date"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DATETIME"

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:86:5: ( 'integer' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:86:7: 'integer'
            {
            match("integer"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "DECIMAL"
    public final void mDECIMAL() throws RecognitionException {
        try {
            int _type = DECIMAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:87:9: ( 'number' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:87:11: 'number'
            {
            match("number"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DECIMAL"

    // $ANTLR start "BINARY"
    public final void mBINARY() throws RecognitionException {
        try {
            int _type = BINARY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:88:8: ( 'blob' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:88:10: 'blob'
            {
            match("blob"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BINARY"

    // $ANTLR start "CREATE"
    public final void mCREATE() throws RecognitionException {
        try {
            int _type = CREATE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:89:8: ( 'create' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:89:10: 'create'
            {
            match("create"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "CREATE"

    // $ANTLR start "TABLE"
    public final void mTABLE() throws RecognitionException {
        try {
            int _type = TABLE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:90:7: ( 'table' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:90:9: 'table'
            {
            match("table"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TABLE"

    // $ANTLR start "DROP"
    public final void mDROP() throws RecognitionException {
        try {
            int _type = DROP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:91:6: ( 'drop' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:91:8: 'drop'
            {
            match("drop"); if (state.failed) return ;


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DROP"

    // $ANTLR start "Whitespace"
    public final void mWhitespace() throws RecognitionException {
        try {
            int _type = Whitespace;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:327:5: ( ( ' ' | '\\t' | '\\n' | '\\r' ) )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:327:7: ( ' ' | '\\t' | '\\n' | '\\r' )
            {
            if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            if ( state.backtracking==0 ) {
               _channel = HIDDEN; 
            }

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Whitespace"

    // $ANTLR start "SingleLineComment"
    public final void mSingleLineComment() throws RecognitionException {
        try {
            int _type = SingleLineComment;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:330:5: ( '--' (~ ( '\\r' | '\\n' ) )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:330:7: '--' (~ ( '\\r' | '\\n' ) )*
            {
            match("--"); if (state.failed) return ;

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:330:11: (~ ( '\\r' | '\\n' ) )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:330:13: ~ ( '\\r' | '\\n' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               _channel = HIDDEN; 
            }

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SingleLineComment"

    // $ANTLR start "MultiLineComment"
    public final void mMultiLineComment() throws RecognitionException {
        try {
            int _type = MultiLineComment;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:333:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:333:7: '/*' ( options {greedy=false; } : . )* '*/'
            {
            match("/*"); if (state.failed) return ;

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:333:12: ( options {greedy=false; } : . )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0=='*') ) {
                    int LA2_1 = input.LA(2);

                    if ( (LA2_1=='/') ) {
                        alt2=2;
                    }
                    else if ( ((LA2_1>='\u0000' && LA2_1<='.')||(LA2_1>='0' && LA2_1<='\uFFFF')) ) {
                        alt2=1;
                    }


                }
                else if ( ((LA2_0>='\u0000' && LA2_0<=')')||(LA2_0>='+' && LA2_0<='\uFFFF')) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:333:40: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);

            match("*/"); if (state.failed) return ;

            if ( state.backtracking==0 ) {
               _channel = HIDDEN; 
            }

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MultiLineComment"

    // $ANTLR start "StringLiteral"
    public final void mStringLiteral() throws RecognitionException {
        try {
            int _type = StringLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:14: ( '\\'' (~ '\\'' )* '\\'' ( '\\'' (~ '\\'' )* '\\'' )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:16: '\\'' (~ '\\'' )* '\\'' ( '\\'' (~ '\\'' )* '\\'' )*
            {
            match('\''); if (state.failed) return ;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:21: (~ '\\'' )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0>='\u0000' && LA3_0<='&')||(LA3_0>='(' && LA3_0<='\uFFFF')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:22: ~ '\\''
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

            match('\''); if (state.failed) return ;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:35: ( '\\'' (~ '\\'' )* '\\'' )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0=='\'') ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:37: '\\'' (~ '\\'' )* '\\''
            	    {
            	    match('\''); if (state.failed) return ;
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:42: (~ '\\'' )*
            	    loop4:
            	    do {
            	        int alt4=2;
            	        int LA4_0 = input.LA(1);

            	        if ( ((LA4_0>='\u0000' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='\uFFFF')) ) {
            	            alt4=1;
            	        }


            	        switch (alt4) {
            	    	case 1 :
            	    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:336:43: ~ '\\''
            	    	    {
            	    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
            	    	        input.consume();
            	    	    state.failed=false;
            	    	    }
            	    	    else {
            	    	        if (state.backtracking>0) {state.failed=true; return ;}
            	    	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	    	        recover(mse);
            	    	        throw mse;}


            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop4;
            	        }
            	    } while (true);

            	    match('\''); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "StringLiteral"

    // $ANTLR start "Integer"
    public final void mInteger() throws RecognitionException {
        try {
            int _type = Integer;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:337:9: ( ( DigitChar )+ )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:337:10: ( DigitChar )+
            {
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:337:10: ( DigitChar )+
            int cnt6=0;
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( ((LA6_0>='0' && LA6_0<='9')) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:337:11: DigitChar
            	    {
            	    mDigitChar(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    if ( cnt6 >= 1 ) break loop6;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(6, input);
                        throw eee;
                }
                cnt6++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Integer"

    // $ANTLR start "Real"
    public final void mReal() throws RecognitionException {
        try {
            int _type = Real;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:339:2: ( Integer '.' Integer | '.' Integer | Integer 'e' ( '+' | '-' )? Integer )
            int alt8=3;
            alt8 = dfa8.predict(input);
            switch (alt8) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:340:2: Integer '.' Integer
                    {
                    mInteger(); if (state.failed) return ;
                    match('.'); if (state.failed) return ;
                    mInteger(); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:341:4: '.' Integer
                    {
                    match('.'); if (state.failed) return ;
                    mInteger(); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:342:4: Integer 'e' ( '+' | '-' )? Integer
                    {
                    mInteger(); if (state.failed) return ;
                    match('e'); if (state.failed) return ;
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:342:16: ( '+' | '-' )?
                    int alt7=2;
                    int LA7_0 = input.LA(1);

                    if ( (LA7_0=='+'||LA7_0=='-') ) {
                        alt7=1;
                    }
                    switch (alt7) {
                        case 1 :
                            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
                            {
                            if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                                input.consume();
                            state.failed=false;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return ;}
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                recover(mse);
                                throw mse;}


                            }
                            break;

                    }

                    mInteger(); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Real"

    // $ANTLR start "QuotedIdentifier"
    public final void mQuotedIdentifier() throws RecognitionException {
        try {
            int _type = QuotedIdentifier;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:2: ( '\"' (~ '\"' )* '\"' ( '.' '\"' (~ '\"' )* '\"' )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:3: '\"' (~ '\"' )* '\"' ( '.' '\"' (~ '\"' )* '\"' )*
            {
            match('\"'); if (state.failed) return ;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:7: (~ '\"' )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( ((LA9_0>='\u0000' && LA9_0<='!')||(LA9_0>='#' && LA9_0<='\uFFFF')) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:8: ~ '\"'
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop9;
                }
            } while (true);

            match('\"'); if (state.failed) return ;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:19: ( '.' '\"' (~ '\"' )* '\"' )*
            loop11:
            do {
                int alt11=2;
                int LA11_0 = input.LA(1);

                if ( (LA11_0=='.') ) {
                    alt11=1;
                }


                switch (alt11) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:20: '.' '\"' (~ '\"' )* '\"'
            	    {
            	    match('.'); if (state.failed) return ;
            	    match('\"'); if (state.failed) return ;
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:28: (~ '\"' )*
            	    loop10:
            	    do {
            	        int alt10=2;
            	        int LA10_0 = input.LA(1);

            	        if ( ((LA10_0>='\u0000' && LA10_0<='!')||(LA10_0>='#' && LA10_0<='\uFFFF')) ) {
            	            alt10=1;
            	        }


            	        switch (alt10) {
            	    	case 1 :
            	    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:345:29: ~ '\"'
            	    	    {
            	    	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
            	    	        input.consume();
            	    	    state.failed=false;
            	    	    }
            	    	    else {
            	    	        if (state.backtracking>0) {state.failed=true; return ;}
            	    	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	    	        recover(mse);
            	    	        throw mse;}


            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop10;
            	        }
            	    } while (true);

            	    match('\"'); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "QuotedIdentifier"

    // $ANTLR start "NonQuotedIdentifier"
    public final void mNonQuotedIdentifier() throws RecognitionException {
        try {
            int _type = NonQuotedIdentifier;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:348:30: ( NonQuotedIdentifier_0 ( DOT NonQuotedIdentifier_0 )* ( DOT MUL )? )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:349:7: NonQuotedIdentifier_0 ( DOT NonQuotedIdentifier_0 )* ( DOT MUL )?
            {
            mNonQuotedIdentifier_0(); if (state.failed) return ;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:349:29: ( DOT NonQuotedIdentifier_0 )*
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( (LA12_0=='.') ) {
                    int LA12_1 = input.LA(2);

                    if ( ((LA12_1>='A' && LA12_1<='Z')||(LA12_1>='a' && LA12_1<='z')) ) {
                        alt12=1;
                    }


                }


                switch (alt12) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:349:30: DOT NonQuotedIdentifier_0
            	    {
            	    mDOT(); if (state.failed) return ;
            	    mNonQuotedIdentifier_0(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);

            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:349:58: ( DOT MUL )?
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0=='.') ) {
                alt13=1;
            }
            switch (alt13) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:349:59: DOT MUL
                    {
                    mDOT(); if (state.failed) return ;
                    mMUL(); if (state.failed) return ;

                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NonQuotedIdentifier"

    // $ANTLR start "NonQuotedIdentifier_0"
    public final void mNonQuotedIdentifier_0() throws RecognitionException {
        try {
            int _type = NonQuotedIdentifier_0;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:352:2: ( LetterChar ( LetterChar | DigitChar | '_' )* )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:352:4: LetterChar ( LetterChar | DigitChar | '_' )*
            {
            mLetterChar(); if (state.failed) return ;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:352:15: ( LetterChar | DigitChar | '_' )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( ((LA14_0>='0' && LA14_0<='9')||(LA14_0>='A' && LA14_0<='Z')||LA14_0=='_'||(LA14_0>='a' && LA14_0<='z')) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
            	    {
            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();
            	    state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NonQuotedIdentifier_0"

    // $ANTLR start "UserVariable"
    public final void mUserVariable() throws RecognitionException {
        try {
            int _type = UserVariable;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:354:13: ( ( ( '@' | ':' | '?' ) ( LetterChar | '_' ) ( '_' | LetterChar | DigitChar )* ) | '?' )
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0=='?') ) {
                int LA16_1 = input.LA(2);

                if ( ((LA16_1>='A' && LA16_1<='Z')||LA16_1=='_'||(LA16_1>='a' && LA16_1<='z')) ) {
                    alt16=1;
                }
                else {
                    alt16=2;}
            }
            else if ( (LA16_0==':'||LA16_0=='@') ) {
                alt16=1;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }
            switch (alt16) {
                case 1 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:354:15: ( ( '@' | ':' | '?' ) ( LetterChar | '_' ) ( '_' | LetterChar | DigitChar )* )
                    {
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:354:15: ( ( '@' | ':' | '?' ) ( LetterChar | '_' ) ( '_' | LetterChar | DigitChar )* )
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:354:16: ( '@' | ':' | '?' ) ( LetterChar | '_' ) ( '_' | LetterChar | DigitChar )*
                    {
                    if ( input.LA(1)==':'||(input.LA(1)>='?' && input.LA(1)<='@') ) {
                        input.consume();
                    state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}

                    if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                        input.consume();
                    state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}

                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:354:53: ( '_' | LetterChar | DigitChar )*
                    loop15:
                    do {
                        int alt15=2;
                        int LA15_0 = input.LA(1);

                        if ( ((LA15_0>='0' && LA15_0<='9')||(LA15_0>='A' && LA15_0<='Z')||LA15_0=='_'||(LA15_0>='a' && LA15_0<='z')) ) {
                            alt15=1;
                        }


                        switch (alt15) {
                    	case 1 :
                    	    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
                    	    {
                    	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                    	        input.consume();
                    	    state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;}


                    	    }
                    	    break;

                    	default :
                    	    break loop15;
                        }
                    } while (true);


                    }


                    }
                    break;
                case 2 :
                    // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:354:88: '?'
                    {
                    match('?'); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UserVariable"

    // $ANTLR start "LetterChar"
    public final void mLetterChar() throws RecognitionException {
        try {
            int _type = LetterChar;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:355:11: ( 'a' .. 'z' | 'A' .. 'Z' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();
            state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LetterChar"

    // $ANTLR start "DigitChar"
    public final void mDigitChar() throws RecognitionException {
        try {
            int _type = DigitChar;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:356:10: ( '0' .. '9' )
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:356:12: '0' .. '9'
            {
            matchRange('0','9'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DigitChar"

    // $ANTLR start "TextNode"
    public final void mTextNode() throws RecognitionException {
        try {
            int _type = TextNode;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:360:9: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:360:10: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "TextNode"

    // $ANTLR start "SelectClause"
    public final void mSelectClause() throws RecognitionException {
        try {
            int _type = SelectClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:361:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:361:14: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SelectClause"

    // $ANTLR start "UnionStmt"
    public final void mUnionStmt() throws RecognitionException {
        try {
            int _type = UnionStmt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:362:10: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:362:11: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UnionStmt"

    // $ANTLR start "SelectStmt"
    public final void mSelectStmt() throws RecognitionException {
        try {
            int _type = SelectStmt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:363:11: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:363:12: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SelectStmt"

    // $ANTLR start "WhereClause"
    public final void mWhereClause() throws RecognitionException {
        try {
            int _type = WhereClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:364:12: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:364:13: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WhereClause"

    // $ANTLR start "GroupByClause"
    public final void mGroupByClause() throws RecognitionException {
        try {
            int _type = GroupByClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:365:14: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:365:15: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GroupByClause"

    // $ANTLR start "OrderByClause"
    public final void mOrderByClause() throws RecognitionException {
        try {
            int _type = OrderByClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:366:14: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:366:15: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OrderByClause"

    // $ANTLR start "OrderByItem"
    public final void mOrderByItem() throws RecognitionException {
        try {
            int _type = OrderByItem;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:367:12: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:367:13: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OrderByItem"

    // $ANTLR start "UpdateClause"
    public final void mUpdateClause() throws RecognitionException {
        try {
            int _type = UpdateClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:368:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:368:14: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UpdateClause"

    // $ANTLR start "UpdateStmt"
    public final void mUpdateStmt() throws RecognitionException {
        try {
            int _type = UpdateStmt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:369:11: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:369:12: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UpdateStmt"

    // $ANTLR start "DeleteClause"
    public final void mDeleteClause() throws RecognitionException {
        try {
            int _type = DeleteClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:370:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:370:14: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DeleteClause"

    // $ANTLR start "DeleteStmt"
    public final void mDeleteStmt() throws RecognitionException {
        try {
            int _type = DeleteStmt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:371:11: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:371:12: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DeleteStmt"

    // $ANTLR start "InsertClause"
    public final void mInsertClause() throws RecognitionException {
        try {
            int _type = InsertClause;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:372:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:372:14: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "InsertClause"

    // $ANTLR start "InsertStmt"
    public final void mInsertStmt() throws RecognitionException {
        try {
            int _type = InsertStmt;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:373:11: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:373:12: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "InsertStmt"

    // $ANTLR start "Alias"
    public final void mAlias() throws RecognitionException {
        try {
            int _type = Alias;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:374:6: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:374:7: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Alias"

    // $ANTLR start "Table"
    public final void mTable() throws RecognitionException {
        try {
            int _type = Table;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:375:6: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:375:7: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Table"

    // $ANTLR start "JoinedTable"
    public final void mJoinedTable() throws RecognitionException {
        try {
            int _type = JoinedTable;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:376:12: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:376:13: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "JoinedTable"

    // $ANTLR start "Column"
    public final void mColumn() throws RecognitionException {
        try {
            int _type = Column;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:377:7: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:377:8: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Column"

    // $ANTLR start "Predicate"
    public final void mPredicate() throws RecognitionException {
        try {
            int _type = Predicate;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:378:10: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:378:11: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Predicate"

    // $ANTLR start "Predicate_Is"
    public final void mPredicate_Is() throws RecognitionException {
        try {
            int _type = Predicate_Is;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:379:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:379:14: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Predicate_Is"

    // $ANTLR start "DataType"
    public final void mDataType() throws RecognitionException {
        try {
            int _type = DataType;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:380:9: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:380:10: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DataType"

    // $ANTLR start "Group"
    public final void mGroup() throws RecognitionException {
        try {
            int _type = Group;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:381:6: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:381:7: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Group"

    // $ANTLR start "UserFunction"
    public final void mUserFunction() throws RecognitionException {
        try {
            int _type = UserFunction;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:382:13: ()
            // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:382:14: 
            {
            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "UserFunction"

    public void mTokens() throws RecognitionException {
        // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:8: ( Eq | Neq1 | Neq2 | Le1 | Le2 | Lt | Ge1 | Ge2 | Gt | DIV | PLUS | MINUS | MUL | MOD | BITAND | BITNOT | BITOR | BITXOR | LPAREN | RPAREN | COLON | COMMA | SEMI | DOT | ALL | AND | AS | ASC | BETWEEN | BY | CASE | CROSS | DELETE | DESC | DISTINCT | ELSE | END | EXISTS | FOR | FROM | GROUP | HAVING | IN | INNER | INSERT | INTO | IS | JOIN | LEFT | LIKE | NOT | NULL | ON | OR | ORDER | OUTER | RIGHT | SELECT | SET | THEN | UNION | UPDATE | VALUES | WHEN | WHERE | TRUNCATE | SUM | AVG | MAX | MIN | COUNT | LEN | CHAR | NCHAR | VARCHAR | NVARCHAR | TEXT | NTEXT | DATETIME | INT | DECIMAL | BINARY | CREATE | TABLE | DROP | Whitespace | SingleLineComment | MultiLineComment | StringLiteral | Integer | Real | QuotedIdentifier | NonQuotedIdentifier | NonQuotedIdentifier_0 | UserVariable | LetterChar | DigitChar | TextNode | SelectClause | UnionStmt | SelectStmt | WhereClause | GroupByClause | OrderByClause | OrderByItem | UpdateClause | UpdateStmt | DeleteClause | DeleteStmt | InsertClause | InsertStmt | Alias | Table | JoinedTable | Column | Predicate | Predicate_Is | DataType | Group | UserFunction )
        int alt17=120;
        alt17 = dfa17.predict(input);
        switch (alt17) {
            case 1 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:10: Eq
                {
                mEq(); if (state.failed) return ;

                }
                break;
            case 2 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:13: Neq1
                {
                mNeq1(); if (state.failed) return ;

                }
                break;
            case 3 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:18: Neq2
                {
                mNeq2(); if (state.failed) return ;

                }
                break;
            case 4 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:23: Le1
                {
                mLe1(); if (state.failed) return ;

                }
                break;
            case 5 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:27: Le2
                {
                mLe2(); if (state.failed) return ;

                }
                break;
            case 6 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:31: Lt
                {
                mLt(); if (state.failed) return ;

                }
                break;
            case 7 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:34: Ge1
                {
                mGe1(); if (state.failed) return ;

                }
                break;
            case 8 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:38: Ge2
                {
                mGe2(); if (state.failed) return ;

                }
                break;
            case 9 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:42: Gt
                {
                mGt(); if (state.failed) return ;

                }
                break;
            case 10 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:45: DIV
                {
                mDIV(); if (state.failed) return ;

                }
                break;
            case 11 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:49: PLUS
                {
                mPLUS(); if (state.failed) return ;

                }
                break;
            case 12 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:54: MINUS
                {
                mMINUS(); if (state.failed) return ;

                }
                break;
            case 13 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:60: MUL
                {
                mMUL(); if (state.failed) return ;

                }
                break;
            case 14 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:64: MOD
                {
                mMOD(); if (state.failed) return ;

                }
                break;
            case 15 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:68: BITAND
                {
                mBITAND(); if (state.failed) return ;

                }
                break;
            case 16 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:75: BITNOT
                {
                mBITNOT(); if (state.failed) return ;

                }
                break;
            case 17 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:82: BITOR
                {
                mBITOR(); if (state.failed) return ;

                }
                break;
            case 18 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:88: BITXOR
                {
                mBITXOR(); if (state.failed) return ;

                }
                break;
            case 19 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:95: LPAREN
                {
                mLPAREN(); if (state.failed) return ;

                }
                break;
            case 20 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:102: RPAREN
                {
                mRPAREN(); if (state.failed) return ;

                }
                break;
            case 21 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:109: COLON
                {
                mCOLON(); if (state.failed) return ;

                }
                break;
            case 22 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:115: COMMA
                {
                mCOMMA(); if (state.failed) return ;

                }
                break;
            case 23 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:121: SEMI
                {
                mSEMI(); if (state.failed) return ;

                }
                break;
            case 24 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:126: DOT
                {
                mDOT(); if (state.failed) return ;

                }
                break;
            case 25 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:130: ALL
                {
                mALL(); if (state.failed) return ;

                }
                break;
            case 26 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:134: AND
                {
                mAND(); if (state.failed) return ;

                }
                break;
            case 27 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:138: AS
                {
                mAS(); if (state.failed) return ;

                }
                break;
            case 28 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:141: ASC
                {
                mASC(); if (state.failed) return ;

                }
                break;
            case 29 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:145: BETWEEN
                {
                mBETWEEN(); if (state.failed) return ;

                }
                break;
            case 30 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:153: BY
                {
                mBY(); if (state.failed) return ;

                }
                break;
            case 31 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:156: CASE
                {
                mCASE(); if (state.failed) return ;

                }
                break;
            case 32 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:161: CROSS
                {
                mCROSS(); if (state.failed) return ;

                }
                break;
            case 33 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:167: DELETE
                {
                mDELETE(); if (state.failed) return ;

                }
                break;
            case 34 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:174: DESC
                {
                mDESC(); if (state.failed) return ;

                }
                break;
            case 35 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:179: DISTINCT
                {
                mDISTINCT(); if (state.failed) return ;

                }
                break;
            case 36 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:188: ELSE
                {
                mELSE(); if (state.failed) return ;

                }
                break;
            case 37 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:193: END
                {
                mEND(); if (state.failed) return ;

                }
                break;
            case 38 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:197: EXISTS
                {
                mEXISTS(); if (state.failed) return ;

                }
                break;
            case 39 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:204: FOR
                {
                mFOR(); if (state.failed) return ;

                }
                break;
            case 40 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:208: FROM
                {
                mFROM(); if (state.failed) return ;

                }
                break;
            case 41 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:213: GROUP
                {
                mGROUP(); if (state.failed) return ;

                }
                break;
            case 42 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:219: HAVING
                {
                mHAVING(); if (state.failed) return ;

                }
                break;
            case 43 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:226: IN
                {
                mIN(); if (state.failed) return ;

                }
                break;
            case 44 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:229: INNER
                {
                mINNER(); if (state.failed) return ;

                }
                break;
            case 45 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:235: INSERT
                {
                mINSERT(); if (state.failed) return ;

                }
                break;
            case 46 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:242: INTO
                {
                mINTO(); if (state.failed) return ;

                }
                break;
            case 47 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:247: IS
                {
                mIS(); if (state.failed) return ;

                }
                break;
            case 48 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:250: JOIN
                {
                mJOIN(); if (state.failed) return ;

                }
                break;
            case 49 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:255: LEFT
                {
                mLEFT(); if (state.failed) return ;

                }
                break;
            case 50 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:260: LIKE
                {
                mLIKE(); if (state.failed) return ;

                }
                break;
            case 51 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:265: NOT
                {
                mNOT(); if (state.failed) return ;

                }
                break;
            case 52 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:269: NULL
                {
                mNULL(); if (state.failed) return ;

                }
                break;
            case 53 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:274: ON
                {
                mON(); if (state.failed) return ;

                }
                break;
            case 54 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:277: OR
                {
                mOR(); if (state.failed) return ;

                }
                break;
            case 55 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:280: ORDER
                {
                mORDER(); if (state.failed) return ;

                }
                break;
            case 56 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:286: OUTER
                {
                mOUTER(); if (state.failed) return ;

                }
                break;
            case 57 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:292: RIGHT
                {
                mRIGHT(); if (state.failed) return ;

                }
                break;
            case 58 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:298: SELECT
                {
                mSELECT(); if (state.failed) return ;

                }
                break;
            case 59 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:305: SET
                {
                mSET(); if (state.failed) return ;

                }
                break;
            case 60 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:309: THEN
                {
                mTHEN(); if (state.failed) return ;

                }
                break;
            case 61 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:314: UNION
                {
                mUNION(); if (state.failed) return ;

                }
                break;
            case 62 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:320: UPDATE
                {
                mUPDATE(); if (state.failed) return ;

                }
                break;
            case 63 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:327: VALUES
                {
                mVALUES(); if (state.failed) return ;

                }
                break;
            case 64 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:334: WHEN
                {
                mWHEN(); if (state.failed) return ;

                }
                break;
            case 65 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:339: WHERE
                {
                mWHERE(); if (state.failed) return ;

                }
                break;
            case 66 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:345: TRUNCATE
                {
                mTRUNCATE(); if (state.failed) return ;

                }
                break;
            case 67 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:354: SUM
                {
                mSUM(); if (state.failed) return ;

                }
                break;
            case 68 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:358: AVG
                {
                mAVG(); if (state.failed) return ;

                }
                break;
            case 69 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:362: MAX
                {
                mMAX(); if (state.failed) return ;

                }
                break;
            case 70 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:366: MIN
                {
                mMIN(); if (state.failed) return ;

                }
                break;
            case 71 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:370: COUNT
                {
                mCOUNT(); if (state.failed) return ;

                }
                break;
            case 72 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:376: LEN
                {
                mLEN(); if (state.failed) return ;

                }
                break;
            case 73 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:380: CHAR
                {
                mCHAR(); if (state.failed) return ;

                }
                break;
            case 74 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:385: NCHAR
                {
                mNCHAR(); if (state.failed) return ;

                }
                break;
            case 75 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:391: VARCHAR
                {
                mVARCHAR(); if (state.failed) return ;

                }
                break;
            case 76 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:399: NVARCHAR
                {
                mNVARCHAR(); if (state.failed) return ;

                }
                break;
            case 77 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:408: TEXT
                {
                mTEXT(); if (state.failed) return ;

                }
                break;
            case 78 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:413: NTEXT
                {
                mNTEXT(); if (state.failed) return ;

                }
                break;
            case 79 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:419: DATETIME
                {
                mDATETIME(); if (state.failed) return ;

                }
                break;
            case 80 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:428: INT
                {
                mINT(); if (state.failed) return ;

                }
                break;
            case 81 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:432: DECIMAL
                {
                mDECIMAL(); if (state.failed) return ;

                }
                break;
            case 82 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:440: BINARY
                {
                mBINARY(); if (state.failed) return ;

                }
                break;
            case 83 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:447: CREATE
                {
                mCREATE(); if (state.failed) return ;

                }
                break;
            case 84 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:454: TABLE
                {
                mTABLE(); if (state.failed) return ;

                }
                break;
            case 85 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:460: DROP
                {
                mDROP(); if (state.failed) return ;

                }
                break;
            case 86 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:465: Whitespace
                {
                mWhitespace(); if (state.failed) return ;

                }
                break;
            case 87 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:476: SingleLineComment
                {
                mSingleLineComment(); if (state.failed) return ;

                }
                break;
            case 88 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:494: MultiLineComment
                {
                mMultiLineComment(); if (state.failed) return ;

                }
                break;
            case 89 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:511: StringLiteral
                {
                mStringLiteral(); if (state.failed) return ;

                }
                break;
            case 90 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:525: Integer
                {
                mInteger(); if (state.failed) return ;

                }
                break;
            case 91 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:533: Real
                {
                mReal(); if (state.failed) return ;

                }
                break;
            case 92 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:538: QuotedIdentifier
                {
                mQuotedIdentifier(); if (state.failed) return ;

                }
                break;
            case 93 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:555: NonQuotedIdentifier
                {
                mNonQuotedIdentifier(); if (state.failed) return ;

                }
                break;
            case 94 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:575: NonQuotedIdentifier_0
                {
                mNonQuotedIdentifier_0(); if (state.failed) return ;

                }
                break;
            case 95 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:597: UserVariable
                {
                mUserVariable(); if (state.failed) return ;

                }
                break;
            case 96 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:610: LetterChar
                {
                mLetterChar(); if (state.failed) return ;

                }
                break;
            case 97 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:621: DigitChar
                {
                mDigitChar(); if (state.failed) return ;

                }
                break;
            case 98 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:631: TextNode
                {
                mTextNode(); if (state.failed) return ;

                }
                break;
            case 99 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:640: SelectClause
                {
                mSelectClause(); if (state.failed) return ;

                }
                break;
            case 100 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:653: UnionStmt
                {
                mUnionStmt(); if (state.failed) return ;

                }
                break;
            case 101 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:663: SelectStmt
                {
                mSelectStmt(); if (state.failed) return ;

                }
                break;
            case 102 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:674: WhereClause
                {
                mWhereClause(); if (state.failed) return ;

                }
                break;
            case 103 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:686: GroupByClause
                {
                mGroupByClause(); if (state.failed) return ;

                }
                break;
            case 104 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:700: OrderByClause
                {
                mOrderByClause(); if (state.failed) return ;

                }
                break;
            case 105 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:714: OrderByItem
                {
                mOrderByItem(); if (state.failed) return ;

                }
                break;
            case 106 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:726: UpdateClause
                {
                mUpdateClause(); if (state.failed) return ;

                }
                break;
            case 107 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:739: UpdateStmt
                {
                mUpdateStmt(); if (state.failed) return ;

                }
                break;
            case 108 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:750: DeleteClause
                {
                mDeleteClause(); if (state.failed) return ;

                }
                break;
            case 109 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:763: DeleteStmt
                {
                mDeleteStmt(); if (state.failed) return ;

                }
                break;
            case 110 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:774: InsertClause
                {
                mInsertClause(); if (state.failed) return ;

                }
                break;
            case 111 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:787: InsertStmt
                {
                mInsertStmt(); if (state.failed) return ;

                }
                break;
            case 112 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:798: Alias
                {
                mAlias(); if (state.failed) return ;

                }
                break;
            case 113 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:804: Table
                {
                mTable(); if (state.failed) return ;

                }
                break;
            case 114 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:810: JoinedTable
                {
                mJoinedTable(); if (state.failed) return ;

                }
                break;
            case 115 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:822: Column
                {
                mColumn(); if (state.failed) return ;

                }
                break;
            case 116 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:829: Predicate
                {
                mPredicate(); if (state.failed) return ;

                }
                break;
            case 117 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:839: Predicate_Is
                {
                mPredicate_Is(); if (state.failed) return ;

                }
                break;
            case 118 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:852: DataType
                {
                mDataType(); if (state.failed) return ;

                }
                break;
            case 119 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:861: Group
                {
                mGroup(); if (state.failed) return ;

                }
                break;
            case 120 :
                // C:\\eclipse_workspace\\HbaseSQL\\src\\grammar\\HbaseSQL.g:1:867: UserFunction
                {
                mUserFunction(); if (state.failed) return ;

                }
                break;

        }

    }


    protected DFA8 dfa8 = new DFA8(this);
    protected DFA17 dfa17 = new DFA17(this);
    static final String DFA8_eotS =
        "\5\uffff";
    static final String DFA8_eofS =
        "\5\uffff";
    static final String DFA8_minS =
        "\2\56\3\uffff";
    static final String DFA8_maxS =
        "\1\71\1\145\3\uffff";
    static final String DFA8_acceptS =
        "\2\uffff\1\2\1\1\1\3";
    static final String DFA8_specialS =
        "\5\uffff}>";
    static final String[] DFA8_transitionS = {
            "\1\2\1\uffff\12\1",
            "\1\3\1\uffff\12\1\53\uffff\1\4",
            "",
            "",
            ""
    };

    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
    static final short[][] DFA8_transition;

    static {
        int numStates = DFA8_transitionS.length;
        DFA8_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
        }
    }

    class DFA8 extends DFA {

        public DFA8(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 8;
            this.eot = DFA8_eot;
            this.eof = DFA8_eof;
            this.min = DFA8_min;
            this.max = DFA8_max;
            this.accept = DFA8_accept;
            this.special = DFA8_special;
            this.transition = DFA8_transition;
        }
        public String getDescription() {
            return "338:1: Real : ( Integer '.' Integer | '.' Integer | Integer 'e' ( '+' | '-' )? Integer );";
        }
    }
    static final String DFA17_eotS =
        "\1\56\1\uffff\1\61\1\uffff\1\66\1\70\1\uffff\1\72\10\uffff\1\73"+
        "\2\uffff\1\74\24\102\2\uffff\1\157\1\uffff\1\102\21\uffff\2\102"+
        "\1\164\1\102\1\uffff\2\102\1\167\21\102\1\u008e\1\u008f\7\102\1"+
        "\u009a\1\u009c\15\102\1\uffff\1\157\1\u00ac\1\u00ad\1\u00ae\1\uffff"+
        "\1\u00af\1\102\1\uffff\15\102\1\u00be\1\102\1\u00c0\6\102\2\uffff"+
        "\2\102\1\u00ca\1\102\1\u00cc\5\102\1\uffff\1\102\1\uffff\3\102\1"+
        "\u00d6\1\u00d7\10\102\1\u00e1\1\u00e2\4\uffff\1\102\1\u00e4\1\u00e5"+
        "\3\102\1\u00e9\1\u00ea\1\102\1\u00ec\1\102\1\u00ee\1\u00ef\1\u00f0"+
        "\1\uffff\1\102\1\uffff\1\u00f2\4\102\1\u00f7\1\102\1\u00f9\1\u00fa"+
        "\1\uffff\1\u00fb\1\uffff\1\u00fc\10\102\2\uffff\1\u0105\6\102\1"+
        "\u010c\1\102\2\uffff\1\102\2\uffff\1\u010f\1\102\1\u0111\2\uffff"+
        "\1\102\1\uffff\1\102\3\uffff\1\102\1\uffff\1\u0115\1\102\1\u0117"+
        "\1\102\1\uffff\1\102\4\uffff\1\102\1\u011b\1\u011c\1\102\1\u011e"+
        "\1\u011f\1\u0120\1\102\1\uffff\1\102\1\u0123\1\u0124\3\102\1\uffff"+
        "\1\u0128\1\102\1\uffff\1\u012a\1\uffff\1\u012b\1\102\1\u012d\1\uffff"+
        "\1\u012e\1\uffff\1\u012f\1\102\1\u0131\2\uffff\1\102\3\uffff\1\u0133"+
        "\1\102\2\uffff\1\u0135\1\u0136\1\102\1\uffff\1\u0138\2\uffff\1\102"+
        "\3\uffff\1\u013a\1\uffff\1\102\1\uffff\1\102\2\uffff\1\102\1\uffff"+
        "\1\u013e\1\uffff\1\102\1\u0140\1\u0141\1\uffff\1\u0142\3\uffff";
    static final String DFA17_eofS =
        "\u0143\uffff";
    static final String DFA17_minS =
        "\1\11\1\uffff\1\75\1\74\1\75\1\52\1\uffff\1\55\10\uffff\1\101\2"+
        "\uffff\25\60\2\uffff\1\56\1\uffff\1\60\21\uffff\2\60\1\56\1\60\1"+
        "\uffff\2\60\1\56\21\60\2\56\7\60\2\56\15\60\1\uffff\4\56\1\uffff"+
        "\1\56\1\60\1\uffff\15\60\1\56\1\60\1\56\6\60\2\uffff\2\60\1\56\1"+
        "\60\1\56\5\60\1\uffff\1\60\1\uffff\3\60\2\56\10\60\2\56\4\uffff"+
        "\1\60\2\56\3\60\2\56\1\60\1\56\1\60\3\56\1\uffff\1\60\1\uffff\1"+
        "\56\4\60\1\56\1\60\2\56\1\uffff\1\56\1\uffff\1\56\10\60\2\uffff"+
        "\1\56\6\60\1\56\1\60\2\uffff\1\60\2\uffff\1\56\1\60\1\56\2\uffff"+
        "\1\60\1\uffff\1\60\3\uffff\1\60\1\uffff\1\56\1\60\1\56\1\60\1\uffff"+
        "\1\60\4\uffff\1\60\2\56\1\60\3\56\1\60\1\uffff\1\60\2\56\3\60\1"+
        "\uffff\1\56\1\60\1\uffff\1\56\1\uffff\1\56\1\60\1\56\1\uffff\1\56"+
        "\1\uffff\1\56\1\60\1\56\2\uffff\1\60\3\uffff\1\56\1\60\2\uffff\2"+
        "\56\1\60\1\uffff\1\56\2\uffff\1\60\3\uffff\1\56\1\uffff\1\60\1\uffff"+
        "\1\60\2\uffff\1\60\1\uffff\1\56\1\uffff\1\60\2\56\1\uffff\1\56\3"+
        "\uffff";
    static final String DFA17_maxS =
        "\1\176\1\uffff\2\76\1\75\1\52\1\uffff\1\55\10\uffff\1\172\2\uffff"+
        "\1\71\24\172\2\uffff\1\145\1\uffff\1\172\21\uffff\4\172\1\uffff"+
        "\54\172\1\uffff\1\145\3\172\1\uffff\2\172\1\uffff\26\172\2\uffff"+
        "\12\172\1\uffff\1\172\1\uffff\17\172\4\uffff\16\172\1\uffff\1\172"+
        "\1\uffff\11\172\1\uffff\1\172\1\uffff\11\172\2\uffff\11\172\2\uffff"+
        "\1\172\2\uffff\3\172\2\uffff\1\172\1\uffff\1\172\3\uffff\1\172\1"+
        "\uffff\4\172\1\uffff\1\172\4\uffff\10\172\1\uffff\6\172\1\uffff"+
        "\2\172\1\uffff\1\172\1\uffff\3\172\1\uffff\1\172\1\uffff\3\172\2"+
        "\uffff\1\172\3\uffff\2\172\2\uffff\3\172\1\uffff\1\172\2\uffff\1"+
        "\172\3\uffff\1\172\1\uffff\1\172\1\uffff\1\172\2\uffff\1\172\1\uffff"+
        "\1\172\1\uffff\3\172\1\uffff\1\172\3\uffff";
    static final String DFA17_acceptS =
        "\1\uffff\1\1\4\uffff\1\13\1\uffff\1\15\1\16\1\17\1\20\1\21\1\22"+
        "\1\23\1\24\1\uffff\1\26\1\27\25\uffff\1\126\1\131\1\uffff\1\134"+
        "\1\uffff\1\137\1\142\1\2\1\4\1\6\1\3\1\5\1\10\1\7\1\11\1\130\1\12"+
        "\1\127\1\14\1\25\1\30\1\133\4\uffff\1\135\54\uffff\1\132\4\uffff"+
        "\1\33\2\uffff\1\36\26\uffff\1\53\1\57\12\uffff\1\65\1\uffff\1\66"+
        "\17\uffff\1\31\1\32\1\34\1\104\16\uffff\1\45\1\uffff\1\47\11\uffff"+
        "\1\110\1\uffff\1\63\11\uffff\1\73\1\103\11\uffff\1\105\1\106\1\uffff"+
        "\1\122\1\37\3\uffff\1\111\1\115\1\uffff\1\42\1\uffff\1\117\1\125"+
        "\1\44\1\uffff\1\50\4\uffff\1\56\1\uffff\1\60\1\61\1\62\1\64\10\uffff"+
        "\1\74\6\uffff\1\100\2\uffff\1\40\1\uffff\1\107\3\uffff\1\51\1\uffff"+
        "\1\54\3\uffff\1\112\1\116\1\uffff\1\67\1\70\1\71\2\uffff\1\124\1"+
        "\75\3\uffff\1\101\1\uffff\1\123\1\41\1\uffff\1\46\1\52\1\55\1\uffff"+
        "\1\121\1\uffff\1\72\1\uffff\1\76\1\77\1\uffff\1\35\1\uffff\1\120"+
        "\3\uffff\1\43\1\uffff\1\102\1\113\1\114";
    static final String DFA17_specialS =
        "\u0143\uffff}>";
    static final String[] DFA17_transitionS = {
            "\2\50\2\uffff\1\50\22\uffff\1\50\1\3\1\53\2\uffff\1\11\1\12"+
            "\1\51\1\16\1\17\1\10\1\6\1\21\1\7\1\23\1\5\12\52\1\20\1\22\1"+
            "\2\1\1\1\4\2\55\32\54\3\uffff\1\15\2\uffff\1\24\1\25\1\26\1"+
            "\27\1\30\1\31\1\32\1\33\1\34\1\35\1\54\1\36\1\47\1\37\1\40\2"+
            "\54\1\41\1\42\1\43\1\44\1\45\1\46\3\54\1\uffff\1\14\1\uffff"+
            "\1\13",
            "",
            "\1\60\1\57",
            "\1\64\1\62\1\63",
            "\1\65",
            "\1\67",
            "",
            "\1\71",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\32\55\4\uffff\1\55\1\uffff\32\55",
            "",
            "",
            "\12\75",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\76\1"+
            "\103\1\77\4\103\1\100\2\103\1\101\4\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\104\6"+
            "\103\1\106\14\103\1\105\1\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\107\6\103\1"+
            "\112\3\103\1\113\2\103\1\111\2\103\1\110\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\116\3\103\1"+
            "\114\3\103\1\115\10\103\1\117\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\120"+
            "\1\103\1\121\11\103\1\122\2\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\123"+
            "\2\103\1\124\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\125"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\126\31\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\127"+
            "\4\103\1\130\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\131"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\132\3"+
            "\103\1\133\21\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\136\13"+
            "\103\1\134\5\103\1\135\1\137\4\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\140"+
            "\3\103\1\141\2\103\1\142\5\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\10\103\1\143"+
            "\21\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\144\17"+
            "\103\1\145\5\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\150\6\103\1"+
            "\146\11\103\1\147\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\151"+
            "\1\103\1\152\12\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\153\31\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\7\103\1\154\22"+
            "\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\155\7\103\1"+
            "\156\21\103",
            "",
            "",
            "\1\75\1\uffff\12\160\53\uffff\1\75",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\32\103",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\161"+
            "\16\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\3\103\1\162\26"+
            "\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\2\103\1\163\27\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\6\103\1\165\23"+
            "\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\166"+
            "\6\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\170"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\171"+
            "\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\173\11"+
            "\103\1\172\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\24\103\1\174"+
            "\5\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\175\31\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\176"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\177"+
            "\6\103\1\u0080\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u0081"+
            "\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0082"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\u0083"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u0084"+
            "\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\3\103\1\u0085"+
            "\26\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\10\103\1\u0086"+
            "\21\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u0087"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\u0088"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\u0089"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\25\103\1\u008a"+
            "\4\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\15\103\1\u008b\4\103\1\u008c\1\u008d\6\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\10\103\1\u0090"+
            "\21\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\5\103\1\u0091"+
            "\7\103\1\u0092\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\12\103\1\u0093"+
            "\17\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0094"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\u0095"+
            "\1\u0096\15\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\7\103\1\u0097"+
            "\3\103\1\u0098\16\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u0099\31\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\3\103\1\u009b\26\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u009d"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\6\103\1\u009e"+
            "\23\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\u009f"+
            "\7\103\1\u00a0\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\14\103\1\u00a1"+
            "\15\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00a2"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\24\103\1\u00a3"+
            "\5\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\103\1\u00a4"+
            "\30\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\10\103\1\u00a5"+
            "\21\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\3\103\1\u00a6"+
            "\26\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\u00a7"+
            "\5\103\1\u00a8\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00a9"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\27\103\1\u00aa"+
            "\2\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00ab"+
            "\14\103",
            "",
            "\1\75\1\uffff\12\160\53\uffff\1\75",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\26\103\1\u00b0"+
            "\3\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\103\1\u00b1"+
            "\30\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00b2"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u00b3"+
            "\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u00b4\31\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00b5"+
            "\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u00b6"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\103\1\u00b7"+
            "\30\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00b8"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\u00b9"+
            "\27\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u00ba"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00bb"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\17\103\1\u00bc"+
            "\12\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00bd"+
            "\25\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u00bf"+
            "\7\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\14\103\1\u00c1"+
            "\15\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\24\103\1\u00c2"+
            "\5\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\10\103\1\u00c3"+
            "\21\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00c4"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00c5"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00c7"+
            "\11\103\1\u00c6\13\103",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00c8"+
            "\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u00c9"+
            "\6\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00cb"+
            "\25\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\u00cd"+
            "\16\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\103\1\u00ce"+
            "\30\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u00cf\31\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\u00d0"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u00d1"+
            "\10\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00d2"+
            "\25\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00d3"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\7\103\1\u00d4"+
            "\22\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00d5"+
            "\25\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00d8"+
            "\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00d9"+
            "\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\13\103\1\u00da"+
            "\16\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\16\103\1\u00db"+
            "\13\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u00dc\31\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\24\103\1\u00dd"+
            "\5\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\u00de"+
            "\27\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00df"+
            "\3\103\1\u00e0\10\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00e3"+
            "\25\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u00e6"+
            "\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u00e7"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u00e8"+
            "\6\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u00eb"+
            "\6\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\10\103\1\u00ed"+
            "\21\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u00f1"+
            "\6\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\17\103\1\u00f3"+
            "\12\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u00f4"+
            "\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u00f5"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u00f6"+
            "\10\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\6\103\1\u00f8"+
            "\23\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u00fd"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u00fe"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\103\1\u00ff"+
            "\30\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\u0100"+
            "\27\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u0101"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u0102"+
            "\10\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0103"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\u0104"+
            "\27\103",
            "",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\u0106"+
            "\27\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u0107"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u0108"+
            "\14\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0109"+
            "\6\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u010a"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\7\103\1\u010b"+
            "\22\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u010d"+
            "\25\103",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u010e"+
            "\25\103",
            "",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u0110"+
            "\25\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u0112"+
            "\25\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u0113"+
            "\14\103",
            "",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u0114"+
            "\7\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\6\103\1\u0116"+
            "\23\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0118"+
            "\6\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u0119"+
            "\25\103",
            "",
            "",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u011a"+
            "\10\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\7\103\1\u011d"+
            "\22\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0121"+
            "\6\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u0122\31\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u0125"+
            "\25\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\22\103\1\u0126"+
            "\7\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u0127\31\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\15\103\1\u0129"+
            "\14\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\2\103\1\u012c"+
            "\27\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u0130"+
            "\10\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\1\u0132\31\103",
            "",
            "",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0134"+
            "\6\103",
            "",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u0137"+
            "\10\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\23\103\1\u0139"+
            "\6\103",
            "",
            "",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\21\103\1\u013b"+
            "\10\103",
            "",
            "\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff\4\103\1\u013c"+
            "\25\103",
            "",
            "",
            "\2\103\1\u013d\7\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\2\103\1\u013f\7\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "\1\102\1\uffff\12\103\7\uffff\32\103\4\uffff\1\103\1\uffff"+
            "\32\103",
            "",
            "",
            ""
    };

    static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
    static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
    static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
    static final short[][] DFA17_transition;

    static {
        int numStates = DFA17_transitionS.length;
        DFA17_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
        }
    }

    class DFA17 extends DFA {

        public DFA17(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 17;
            this.eot = DFA17_eot;
            this.eof = DFA17_eof;
            this.min = DFA17_min;
            this.max = DFA17_max;
            this.accept = DFA17_accept;
            this.special = DFA17_special;
            this.transition = DFA17_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( Eq | Neq1 | Neq2 | Le1 | Le2 | Lt | Ge1 | Ge2 | Gt | DIV | PLUS | MINUS | MUL | MOD | BITAND | BITNOT | BITOR | BITXOR | LPAREN | RPAREN | COLON | COMMA | SEMI | DOT | ALL | AND | AS | ASC | BETWEEN | BY | CASE | CROSS | DELETE | DESC | DISTINCT | ELSE | END | EXISTS | FOR | FROM | GROUP | HAVING | IN | INNER | INSERT | INTO | IS | JOIN | LEFT | LIKE | NOT | NULL | ON | OR | ORDER | OUTER | RIGHT | SELECT | SET | THEN | UNION | UPDATE | VALUES | WHEN | WHERE | TRUNCATE | SUM | AVG | MAX | MIN | COUNT | LEN | CHAR | NCHAR | VARCHAR | NVARCHAR | TEXT | NTEXT | DATETIME | INT | DECIMAL | BINARY | CREATE | TABLE | DROP | Whitespace | SingleLineComment | MultiLineComment | StringLiteral | Integer | Real | QuotedIdentifier | NonQuotedIdentifier | NonQuotedIdentifier_0 | UserVariable | LetterChar | DigitChar | TextNode | SelectClause | UnionStmt | SelectStmt | WhereClause | GroupByClause | OrderByClause | OrderByItem | UpdateClause | UpdateStmt | DeleteClause | DeleteStmt | InsertClause | InsertStmt | Alias | Table | JoinedTable | Column | Predicate | Predicate_Is | DataType | Group | UserFunction );";
        }
    }
 

}